# Llibreries bàsiques
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
import numpy as np

# Llibreries addicionals (justificar el seu ús)

# Comprovar les versions
print("NetworkX ver. {}".format(nx.__version__))
print("Pandas ver. {}".format(pd.__version__))
print("Numpy ver. {}".format(np.__version__))

NetworkX ver. 3.2.1
Pandas ver. 2.2.3
Numpy ver. 1.26.4

import csv # Per crear un csv_reader i usar la funció next() per saltar les capçaleres # Bibliografia: [Ref.1]
def create_graph_of_season(nodes, edges):
    graph = nx.Graph()
    # -- Afegir nodes --
    with open(nodes) as f:
        csv_reader = csv.reader(f) # Bibliografia: [Ref.1]
        header = next(csv_reader) # Bibliografia: [Ref.1]
        for line in csv_reader:
            id_character = line[0].strip()
            label_character = line[1].strip()
            graph.add_node(id_character, label=label_character) # Bibliografia: [Ref.2]
    f.close()
    current_nodes = list(graph.nodes()) # Per a comprovar si falta algun node (no esta aquí però sí a les arestes) # Bibliografia: [Ref.3]
    # -- Afegir arestes --
    with open(edges) as f:
        csv_reader = csv.reader(f) # Bibliografia: [Ref.1]
        header = next(csv_reader) # Bibliografia: [Ref.1]
        for line in csv_reader:
            source = line[0].strip()
            target = line[1].strip()
            weight = int(line[2].strip())
            season = line[3].strip()
            if source not in current_nodes:
                graph.add_node(source, label=source.capitalize()) # Bibliografia: [Ref.4]
                current_nodes = list(graph.nodes())
            if target not in current_nodes:
                graph.add_node(target, label=target.capitalize()) # Bibliografia: [Ref.4]
                current_nodes = list(graph.nodes())
            graph.add_edge(source, target, weight=weight, season=season)
    f.close()
    return graph

# -- Season 1 --
nodes_s1 = "gameofthrones/data/got-s1-nodes.csv"
edges_s1 = "gameofthrones/data/got-s1-edges.csv"
graph_s1 = create_graph_of_season(nodes_s1, edges_s1)
num_nodes_s1 = len(list(graph_s1.nodes()))
num_edges_s1 = len(list(graph_s1.edges()))

# -- Season 2 --
nodes_s2 = "gameofthrones/data/got-s2-nodes.csv"
edges_s2 = "gameofthrones/data/got-s2-edges.csv"
graph_s2 = create_graph_of_season(nodes_s2, edges_s2)
num_nodes_s2 = len(list(graph_s2.nodes()))
num_edges_s2 = len(list(graph_s2.edges()))

# -- Season 3 --
nodes_s3 = "gameofthrones/data/got-s3-nodes.csv"
edges_s3 = "gameofthrones/data/got-s3-edges.csv"
graph_s3 = create_graph_of_season(nodes_s3, edges_s3)
num_nodes_s3 = len(list(graph_s3.nodes()))
num_edges_s3 = len(list(graph_s3.edges()))

# -- Season 4 --
nodes_s4 = "gameofthrones/data/got-s4-nodes.csv"
edges_s4 = "gameofthrones/data/got-s4-edges.csv"
graph_s4 = create_graph_of_season(nodes_s4, edges_s4)
num_nodes_s4 = len(list(graph_s4.nodes()))
num_edges_s4 = len(list(graph_s4.edges()))

# -- Season 5 --
nodes_s5 = "gameofthrones/data/got-s5-nodes.csv"
edges_s5 = "gameofthrones/data/got-s5-edges.csv"
graph_s5 = create_graph_of_season(nodes_s5, edges_s5)
num_nodes_s5 = len(list(graph_s5.nodes()))
num_edges_s5 = len(list(graph_s5.edges()))

# -- Season 6 --
nodes_s6 = "gameofthrones/data/got-s6-nodes.csv"
edges_s6 = "gameofthrones/data/got-s6-edges.csv"
graph_s6 = create_graph_of_season(nodes_s6, edges_s6)
num_nodes_s6 = len(list(graph_s6.nodes()))
num_edges_s6 = len(list(graph_s6.edges()))

# -- Season 7 --
nodes_s7 = "gameofthrones/data/got-s7-nodes.csv"
edges_s7 = "gameofthrones/data/got-s7-edges.csv"
graph_s7 = create_graph_of_season(nodes_s7, edges_s7)
num_nodes_s7 = len(list(graph_s7.nodes()))
num_edges_s7 = len(list(graph_s7.edges()))

# -- Season 8 --
nodes_s8 = "gameofthrones/data/got-s8-nodes.csv"
edges_s8 = "gameofthrones/data/got-s8-edges.csv"
graph_s8 = create_graph_of_season(nodes_s8, edges_s8)
num_nodes_s8 = len(list(graph_s8.nodes()))
num_edges_s8 = len(list(graph_s8.edges()))

print("---------------------------------------- Temporada 1 ----------------------------------------")
print(f"Nodes de la temporada 1: {num_nodes_s1}")
print(f"Arestes de la temporada 1: {num_edges_s1}\n")
print("---------------------------------------- Temporada 2 ----------------------------------------")
print(f"Nodes de la temporada 2: {num_nodes_s2}")
print(f"Arestes de la temporada 2: {num_edges_s2}\n")
print("---------------------------------------- Temporada 3 ----------------------------------------")
print(f"Nodes de la temporada 3: {num_nodes_s3}")
print(f"Arestes de la temporada 3: {num_edges_s3}\n")
print("---------------------------------------- Temporada 4 ----------------------------------------")
print(f"Nodes de la temporada 4: {num_nodes_s4}")
print(f"Arestes de la temporada 4: {num_edges_s4}\n")
print("---------------------------------------- Temporada 5 ----------------------------------------")
print(f"Nodes de la temporada 5: {num_nodes_s5}")
print(f"Arestes de la temporada 5: {num_edges_s5}\n")
print("---------------------------------------- Temporada 6 ----------------------------------------")
print(f"Nodes de la temporada 6: {num_nodes_s6}")
print(f"Arestes de la temporada 6: {num_edges_s6}")
print("---------------------------------------- Temporada 7 ----------------------------------------")
print(f"Nodes de la temporada 7: {num_nodes_s7}")
print(f"Arestes de la temporada 7: {num_edges_s7}\n")
print("---------------------------------------- Temporada 8 ----------------------------------------")
print(f"Nodes de la temporada 8: {num_nodes_s8}")
print(f"Arestes de la temporada 8: {num_edges_s8}")

---------------------------------------- Temporada 1 ----------------------------------------
Nodes de la temporada 1: 126
Arestes de la temporada 1: 549

---------------------------------------- Temporada 2 ----------------------------------------
Nodes de la temporada 2: 129
Arestes de la temporada 2: 486

---------------------------------------- Temporada 3 ----------------------------------------
Nodes de la temporada 3: 124
Arestes de la temporada 3: 504

---------------------------------------- Temporada 4 ----------------------------------------
Nodes de la temporada 4: 172
Arestes de la temporada 4: 667

---------------------------------------- Temporada 5 ----------------------------------------
Nodes de la temporada 5: 119
Arestes de la temporada 5: 396

---------------------------------------- Temporada 6 ----------------------------------------
Nodes de la temporada 6: 142
Arestes de la temporada 6: 541
---------------------------------------- Temporada 7 ----------------------------------------
Nodes de la temporada 7: 81
Arestes de la temporada 7: 412

---------------------------------------- Temporada 8 ----------------------------------------
Nodes de la temporada 8: 74
Arestes de la temporada 8: 553

# --- Aquest exercici ha estat resolt amb l'ajuda de [Ref.5] -> Ús 1 ---
got_dict = {1: graph_s1, 2: graph_s2, 3: graph_s3, 4: graph_s4, 5: graph_s5, 6: graph_s6, 7: graph_s7, 8: graph_s8} # {temporada: graf}
multilayer_got = nx.Graph()
for graph in got_dict.values(): # El compose() uneix tots els grafs de les temporades en un de sol -> Representa la info de tota la sèrie
    multilayer_got = nx.compose(multilayer_got, graph) # Bibliografia: [Ref.6]
base_pos = nx.spring_layout(multilayer_got, k=3) # Bibliografia: [Ref.7]
layer_offset = {season: season * 3.0 for season in got_dict.keys()} # Per a que no es superposin els grafs de les temporades
# -- Càlcul posicions de cada capa --
layer_positions = {}
for character, (coord_x, coord_y) in base_pos.items():
    for season in got_dict:
        layer_positions[(character, season)] = (coord_x + layer_offset[season], coord_y)
# -- Construcció del graf multilayer per visualitzar --
got_multilayer_plot = nx.Graph()
for season, graph in got_dict.items():
    for character in graph.nodes():
        got_multilayer_plot.add_node((character, season))
# -- Connexions --
for season, graph in got_dict.items():
    for character_1, character_2, args in graph.edges(data=True):
        weight = args["weight"]
        got_multilayer_plot.add_edge((character_1, season), (character_2, season), weight=weight)
# -- Connexions entre capes --
for character in multilayer_got.nodes():
    for season in range(1, 8):
        if character in got_dict[season] and character in got_dict[season + 1]:
            got_multilayer_plot.add_edge((character, season), (character, season + 1))
# -- Visualització --
plt.figure(figsize=(100,100))
# - Dibuix connexions de cada capa -
for season in got_dict.keys():
    edges = [edge for edge in got_multilayer_plot.edges() if edge[0][1] == season and edge[1][1] == season]
    nx.draw_networkx_edges(got_multilayer_plot, layer_positions, edgelist=edges, edge_color='r') # Bibliografia: [Ref.8]
# - Dibuix connexions entre capes -
interlayer_edges = [edge for edge in got_multilayer_plot.edges() if edge[0][1] != edge[1][1]]
nx.draw_networkx_edges(got_multilayer_plot, layer_positions, edgelist=interlayer_edges, edge_color='b') # Bibliografia: [Ref.8]
# - Dibuix nodes -
nx.draw_networkx_nodes(got_multilayer_plot, layer_positions, node_size = 200, node_color='k') # Bibliografia: [Ref.9]
plt.axis("off") # Bibliografia: [Ref.10]
plt.title("Xarxa multicapa de la sèrie Joc de trons. Cada capa de la xarxa és una temporada de la sèrie", fontsize=90)
plt.show()

# -- Obtenció dels graus --
degrees_seasons = {} # Per guardar cada DegreeView amb la seva temporada
for season, graph_season in got_dict.items():
    degrees_seasons[season] = graph_season.degree() # Bibliografia: [Ref.11]

# -- Representació dels graus -- # Bibliografia: [Ref.12]
fig, ax = plt.subplots(2, 4, figsize=(15,15))
fig.suptitle("Distribució de graus de les 8 temporades de Joc de Trons") # Bibliografia: [Ref.13] i [Ref.5] -> Ús 2
k = 1
for i in range(2):
    for j in range(4):
        degree_view = degrees_seasons[k]
        degrees = [degree for character, degree in degree_view]
        ax[i, j].hist(degrees, edgecolor='black', bins=20) # Bibliografia: [Ref.14] i [Ref.15]
        ax[i, j].set_title(f"Distribució de graus de la temporada {k}", fontsize=10) # Bibliografia: [Ref.16]
        ax[i, j].set_ylabel("Freqüència") # Bibliografia: [Ref.17]
        ax[i, j].set_xlabel("Graus") # Bibliografia: [Ref.18]
        k += 1
plt.show()

from numpy import linalg
def von_neuman_entropy(graph):
    laplacian = nx.laplacian_matrix(graph).toarray() # Bibliografia: [Ref.19]
    num_edges = graph.number_of_edges() # Bibliografia: [Ref.20]
    c = 1 / (2 * num_edges) # Factor de reescalat matriu laplaciana
    laplacian_rescaled = c * laplacian
    eigenvalues = linalg.eigvalsh(laplacian_rescaled) # Bibliografia: [Ref.21]
    eigenvalues_non_zero = np.array([eigval for eigval in eigenvalues if eigval > 1e-12]) # Bibliografia: [Ref.5] -> Ús3
    entropy = -np.sum(eigenvalues_non_zero * np.log2(eigenvalues_non_zero))
    return entropy

entropy_layer_1 = von_neuman_entropy(graph_s1)
print(f"Entropia de la capa 1: {entropy_layer_1}\n")
entropy_layer_2 = von_neuman_entropy(graph_s2)
print(f"Entropia de la capa 2: {entropy_layer_2}\n")
entropy_layer_3 = von_neuman_entropy(graph_s3)
print(f"Entropia de la capa 3: {entropy_layer_3}\n")
entropy_layer_4 = von_neuman_entropy(graph_s4)
print(f"Entropia de la capa 4: {entropy_layer_4}\n")
entropy_layer_5 = von_neuman_entropy(graph_s5)
print(f"Entropia de la capa 5: {entropy_layer_5}\n")
entropy_layer_6 = von_neuman_entropy(graph_s6)
print(f"Entropia de la capa 6: {entropy_layer_6}\n")
entropy_layer_7 = von_neuman_entropy(graph_s7)
print(f"Entropia de la capa 7: {entropy_layer_7}\n")
entropy_layer_8 = von_neuman_entropy(graph_s8)
print(f"Entropia de la capa 8: {entropy_layer_8}\n")
total_entropy = entropy_layer_1 + entropy_layer_2 + entropy_layer_3 + entropy_layer_4 + entropy_layer_5 + entropy_layer_6 + entropy_layer_7 
+ entropy_layer_8
print(f"Entropia total de la xarxa multicapa: {total_entropy}\n")

Entropia de la capa 1: 23.406369015172377

Entropia de la capa 2: 26.992283435648897

Entropia de la capa 3: 28.253890466790462

Entropia de la capa 4: 27.95984797306804

Entropia de la capa 5: 26.038524822433

Entropia de la capa 6: 28.94300152889199

Entropia de la capa 7: 17.80187171391072

Entropia de la capa 8: 15.969990324452684

Entropia total de la xarxa multicapa: 179.39578895591546

entropies = [entropy_layer_1, entropy_layer_2, entropy_layer_3, entropy_layer_4, entropy_layer_5, entropy_layer_6, entropy_layer_7,
             entropy_layer_8]
labels_visualization = ["Entropy layer 1", "Entropy layer 2", "Entropy layer 3", "Entropy layer 4", "Entropy layer 5", "Entropy layer 6",
                        "Entropy layer 7", "Entropy layer 8", ]
plt.figure(figsize=(20,20))
plt.barh(labels_visualization, entropies) # Bibliografia: [Ref.22]
plt.title("Entropies de les capes de la xarxa multicapa de Joc de Trons", fontsize=20)
plt.ylabel("Entropia per capes", fontsize=15)
plt.xlabel("Valor de l'entropia", fontsize=15)
plt.locator_params(axis='x', nbins=20) # Bibliografia: [Ref.23]
plt.grid()
plt.show()

# -- Càlcul de centralitats --
centralities = {}
for season, graph_season in got_dict.items():
    centralities[season] = nx.eigenvector_centrality(graph_season, weight='weight') # Bibliografia: [Ref.24]

# -- Representació --
import seaborn as sns # Per fer la representació de les centralitats
data = pd.DataFrame(centralities)
data.fillna(0, inplace=True) # Si un personatge no apareix en una temporada -> 0  # Bibliografia: [Ref.25]
# - Com hi ha molts personatges, només es mostraran el top 30 de personatges amb més centralitat per tal de fer la visualització més senzilla -
# - Selecció dels 30 personatges amb més centralitat realitzada amb l'ajuda de  # Bibliografia: [Ref.5] -> Ús 4 -
data["sum_centralities"] = data.sum(axis=1) # Bibliografia: [Ref.26]
top = data.sort_values("sum_centralities",ascending=False).head(30) # Bibliografia: [Ref.27]
top.drop(columns="sum_centralities", inplace=True)  # Bibliografia: [Ref.28]

plt.figure(figsize=(20,20))
sns.heatmap(top, linewidths=0.5, annot=True) # Bibliografia: [Ref.29]
plt.show()

# Bibliografia: [Ref.31] -> Ús 1
# Claus en l'explicació de [Ref.31] -> Ús 1:
    # 1. Grau agregat = suma de graus en les capes
    # 2. Percolació -> Eliminar nodes per veure com es fragmenta la xarxa
    # 3. Percolació dirigida per grau i intercapa:
        # 3.1. Els personatges amb mes grau agregat son els primers a ser eliminats.
        # 3.2. En cas de que sigui un dels nodes a eliminar -> cal eliminarlo de totes les capes perquè estem mirant la robustesa de la xarxa
# Passos a seguir segons les claus de les explicacions de [Ref.31] -> Ús 1 i enunciat:
    # Pas 1 --> Calcular graus agregats
    # Pas 2 --> Ordenar els graus agregats de major a menor
    # Pas 3 --> Aplicar percolació
        # Pas 3.1 --> Eliminar el personatge que toqui de la llista de personatges amb grau agregat ordenat (totes les tempordes)
        # Pas 3.2 --> Per cada personatge eliminat --> +1 node eliminat
        # Pas 3.3 --> Calcul component gegant
        # Pas 3.4 --> Calcul de percentatges

# -- Agregació de graus --
agreggated_degrees = {} # Diccionari per guardar parelles "personatge : grau"
for season, graph in got_dict.items():
    for character in graph.nodes():
        agreggated_degrees[character] = agreggated_degrees.get(character, 0) + graph.degree(character, weight='weight') # Bibliografia: [Ref.32]
# Per resoldre aquest exercici cal usar el graf multicapa no les capes per separat. El graf multicapa s'ha creat a l'exercici 2 -> got_multilayer_plot
# -- Ordenat dels personatges per grau --
characters_ordered_percolation = sorted(agreggated_degrees.keys(), key=lambda item:item[1], reverse=True) # Bibliografia: [Ref.33]

# -- Percolació dirigida --
total_nodes = len(got_multilayer_plot.nodes()) # Nombre de nodes totals
directed_percolation_percentage_nodes_removed = []
directed_percolation_percentage_nodes_giant_component = []
percolation_graph = got_multilayer_plot.copy() # Usar una còpia per no trencar el de la visualització
deleted_nodes = 0 # Per calcular el % de nodes eliminats

for character_ordered in characters_ordered_percolation:
    # - Elimincació de personatges al llarg de les temporades -
    for character, season in list(percolation_graph.nodes()):
        if character == character_ordered:
            percolation_graph.remove_node((character, season)) # Bibliografia: [Ref.34]
            deleted_nodes += 1
    # - Càlcul de la component gegant -
    if len(percolation_graph.nodes()) > 0: # Si no hi ha nodes el max() peta
        len_giant_component = len(max(nx.connected_components(percolation_graph), key=len)) # Bibliografia: [Ref.35]
        percentage_removed_nodes = deleted_nodes / total_nodes # Percentatge de nodes eliminats
        percentage_nodes_giant_component = len_giant_component / total_nodes # Percentatge de nodes de la component gegant
        directed_percolation_percentage_nodes_removed.append(percentage_removed_nodes)
        directed_percolation_percentage_nodes_giant_component.append(percentage_nodes_giant_component)

import random # Per fer la ordenació aleatòria dels nodes per la percolació aleatòria
# -- Percolació random --
total_nodes = len(got_multilayer_plot.nodes()) # Nombre de nodes totals
random_percolation_percentage_nodes_removed = []
random_percolation_percentage_nodes_giant_component = []
random_percolation_graph = got_multilayer_plot.copy() # Usar una còpia per no trencar el de la visualització
deleted_nodes = 0 # Per calcular el % de nodes eliminats
# - En comptes d'ordenar per grau agregat -> Ordenació random - # Bibliografia: [Ref.36]
random_order = list(got_multilayer_plot.nodes())
random.shuffle(random_order)

for character_ordered in random_order:
    random_percolation_graph.remove_node(character_ordered)
    deleted_nodes += 1
    # - Càlcul component gegant -
    if len(random_percolation_graph.nodes()) > 0: # Si no hi ha nodes el max peta -> El if es necessàri
        len_giant_component = len(max(nx.connected_components(random_percolation_graph), key=len))
        percentage_removed_nodes = deleted_nodes / total_nodes
        percentage_nodes_giant_component = len_giant_component / total_nodes
        random_percolation_percentage_nodes_removed.append(percentage_removed_nodes)
        random_percolation_percentage_nodes_giant_component.append(percentage_nodes_giant_component)

plt.figure(figsize=(20,20))
plt.plot(directed_percolation_percentage_nodes_removed, directed_percolation_percentage_nodes_giant_component, label="Directed percolation")
plt.plot(random_percolation_percentage_nodes_removed, random_percolation_percentage_nodes_giant_component, label="Random percolation")
plt.title("Percentatge de nodes eliminat vs. Percentatge de nodes de la component gegant després d'un procés de percolació", fontsize=20)
plt.xlabel("Percentatge de nodes eliminats", fontsize=15)
plt.ylabel("Percentatge de nodes de la component gegant", fontsize=15)
plt.locator_params(axis='x', nbins=30)
plt.grid()
plt.legend()
plt.show()

# graph -> Graf d'estudi RSC
# beta1 -> Probabilitat d'infecció 1-simplex -> simplex-1 = Procés estocàstic 1
# beta2 -> Probabilitat infecció 2-simplex -> simplex-2 = Procés estocàstic 2
# mu -> Probabilitat de recuperació
# initial_infected -> Percetntatge d'infectats incials (assignar random)
# time_steps -> les diferents "t".
# Decisió contagi -> "[...]an individual is simultaneously exposed to multiple sources of contagion[...]" -> Prob. combinada P(simplex-1 o simplex2)
# P(simplex-1 o simplex2) = 1 - P(no simplex-1 y no simplex2) [Truco Ref.37] -> 
# P(no simplex-1 y no simplex2) = P(no simplex-1) * P(no simplex2) [Ref.38] i [Ref.39]
# P(no simplex-1) * P(no simplex2) = (1 - P(simplex-1)) * (1 - P(simplex-2)) [Ref.39] ==>
# P(simplex-1 o simplex2) = 1 - [(1 - P(simplex-1)) * (1 - P(simplex-2))]
# 1 - P(simplex-1) = 1 - beta1
# 1 - P(simplex-2) = 1 - beta2
# Bibliografia: [Ref.37] i [Ref.38] i [Ref.39]
def find_triangles_s2(graph):
    triangles = []
    for clique in nx.find_cliques(graph): # Bibliografia: [Ref.40]
        if len(clique) == 3:
            triangles.append(clique)
    return triangles

def scm_order_2(graph, beta1, beta2, mu, initial_infectious=0.1, time_steps=100):
    infectious_percentages = [] # Per guardar el percentatge de infecciosos
    nodes = graph.nodes()
    num_initial_infectious = int(len(nodes) * initial_infectious) # Nombre de nodes inicials infectats
    initial_nodes_infectious = np.random.choice(nodes, num_initial_infectious, replace=False) # Bibliografia: [Ref.41]
    nodes_states = {}
    triangles = find_triangles_s2(graph)
    for node in nodes: 
        if node in initial_nodes_infectious:
            nodes_states[node] = 1 # Si el node està a la llista de infectats inicials -> Estat 1 (Infecciós)
        else:
            nodes_states[node] = 0
    infectious_percentages.append(sum(nodes_states.values()) / len(nodes))
    for step in range(time_steps):
        for node in nodes:
            # -- Si es susceptible es pot infectar --
            if nodes_states[node] == 0:
                infectious_by_simplex1 = 0
                infectious_by_simplex2 = 0
                # - Cas simplex 1 -
                for neighbor in graph.neighbors(node):
                    if nodes_states[neighbor] == 1: # Si el vei es infecciós pot infectar al susceptible
                        infectious_by_simplex1 += 1
                # - Cas simplex 2 - # Bibliograifa: [Ref.31] -> Ús 2
                triangles_for_node = []
                for triangle in triangles:
                    if node in triangle:
                        triangles_for_node.append(triangle)
                for triangle in triangles_for_node:
                    if triangle[0] == node:
                        if nodes_states[triangle[1]] == 1 and nodes_states[triangle[2]] == 1:
                            infectious_by_simplex2 += 1
                    elif triangle[1] == node:
                        if nodes_states[triangle[0]] == 1 and nodes_states[triangle[2]] == 1:
                            infectious_by_simplex2 += 1
                    elif triangle[2] == node:
                        if nodes_states[triangle[0]] == 1 and nodes_states[triangle[1]] == 1:
                            infectious_by_simplex2 += 1
                # - Calcul probabilitat combinada - # Bibliografia: [Ref.37] i [Ref.38] i [Ref.39]
                prob_infect = 1 - (((1 - beta1) ** infectious_by_simplex1) * ((1 - beta2) ** infectious_by_simplex2))
                # - Prendre decisió infeccio -
                if prob_infect > np.random.rand():
                    nodes_states[node] = 1
            # -- Si és infeccios es pot curar --
            elif nodes_states[node] == 1:
                if np.random.rand() < mu:
                    nodes_states[node] = 0
        # - Càlcul densitat infecciosos -
        infectious_percentages.append((1 / len(nodes)) * sum(nodes_states.values()))
    return infectious_percentages

# -- RSC --
from itertools import combinations # Per generar combinacions de 3 nodes en el moment de afegir els triangles al RSC
N = 100
p1 = 0.7
p_delta = 0.6
rsc_graph = nx.Graph()
rsc_graph.add_nodes_from([node for node in range(N)])
for node in rsc_graph.nodes():
    # - Afegir simplex-1 -
    potential_node_to_connect = node
    while potential_node_to_connect == node: # Per evitar connectar-se amb si mateix
        potential_node_to_connect = np.random.choice(rsc_graph.nodes(), 1)
    if np.random.rand() < p1:
        rsc_graph.add_edge(node, potential_node_to_connect[0])

for i, j, k in combinations(list(rsc_graph.nodes()), 3): # Bibliografia: [Ref.42]
    prob = np.random.rand()
    if rsc_graph.has_edge(i, j) and prob < p_delta:
        rsc_graph.add_edge(i, k)
        rsc_graph.add_edge(k, j)
    if rsc_graph.has_edge(i, k) and prob < p_delta:
        rsc_graph.add_edge(i, j)
        rsc_graph.add_edge(k, j)
    if rsc_graph.has_edge(j, k) and prob < p_delta:
        rsc_graph.add_edge(i, j)
        rsc_graph.add_edge(k, i)

test_scm = scm_order_2(rsc_graph, 0.1, 0.3, 0.2)
print(test_scm)

[0.1, 0.97, 0.8200000000000001, 0.86, 0.8, 0.8200000000000001, 0.78, 0.8200000000000001, 0.74, 0.78, 0.84, 0.8300000000000001, 0.8300000000000001, 0.84, 0.8, 0.75, 0.86, 0.79, 0.85, 0.8300000000000001, 0.8200000000000001, 0.86, 0.85, 0.85, 0.77, 0.74, 0.85, 0.77, 0.85, 0.87, 0.85, 0.8300000000000001, 0.84, 0.84, 0.8200000000000001, 0.8300000000000001, 0.8200000000000001, 0.86, 0.77, 0.86, 0.75, 0.9, 0.85, 0.85, 0.89, 0.85, 0.85, 0.73, 0.9, 0.8300000000000001, 0.78, 0.87, 0.86, 0.78, 0.89, 0.85, 0.81, 0.8200000000000001, 0.84, 0.84, 0.71, 0.88, 0.8200000000000001, 0.84, 0.79, 0.92, 0.76, 0.89, 0.8200000000000001, 0.78, 0.88, 0.8300000000000001, 0.8300000000000001, 0.8200000000000001, 0.8300000000000001, 0.85, 0.86, 0.8200000000000001, 0.79, 0.9, 0.8, 0.81, 0.84, 0.79, 0.76, 0.91, 0.85, 0.88, 0.79, 0.85, 0.8, 0.87, 0.86, 0.84, 0.86, 0.8300000000000001, 0.87, 0.8200000000000001, 0.89, 0.9, 0.84]

# -- Graphic 1 --
N = 2000
k = 20
k_delta = 6
mu = 1.0
lambda_values = [round(value, 1) for value in np.arange(0.0, 2.0, 0.1)] # round() per evitar nombres del tipus 1.00000000001 # Bibliografia: [Ref.43]
lambda_delta1 = 0.0
lambda_delta2 = 0.8
lambda_delta3 = 2.5
# -- Generar RSC --
rsc = nx.Graph()
rsc.add_nodes_from([node for node in range(N)])
p1 = (k - (2 * k_delta)) / ((N - 1) - (2 * k_delta))
p_delta = (2 * k_delta) / ((N - 1) * (N - 2))
for i, j in combinations(list(rsc.nodes()), 2):
    # - Simplex 1 -
    if np.random.rand() < p1:
        rsc.add_edge(i, j)
# - Simplex 2 -
for i, j, k in combinations(list(rsc.nodes()), 3): # Bibliografia: [Ref.31] -> ús 3
    if np.random.rand() < p_delta:
        if rsc.has_edge(i, j):
            rsc.add_edge(i, k)
            rsc.add_edge(j, k)
        elif rsc.has_edge(i, k):
            rsc.add_edge(i, j)
            rsc.add_edge(k, j)
        elif rsc.has_edge(j, k):
            rsc.add_edge(i, j)
            rsc.add_edge(i, k)
        else: # Cas extraordinari on cap dels tres nodes te cap aresta que els uneixi
            rsc.add_edge(i, j)
            rsc.add_edge(i, k)
            rsc.add_edge(j, k)

# -- Simulació per a gràfic 1 --
# - Lambda delta = 0.0 -
print("Computing case lambda_delta = 0.0")
results_labda_delta1 = []
for lambda_value in lambda_values:
    # lambda = beta * k / mu ==> beta = lamda * mu / k
    beta1 = (lambda_value * mu) / k
    beta2 = (lambda_delta1 * mu) / k_delta
    scm = scm_order_2(rsc, beta1, beta2, mu, initial_infectious=0.01, time_steps=200) # Bibliografia: [Ref.31] -> Ús 4
    results_labda_delta1.append(np.mean(scm[-100:])) # Bibliografia: [Ref.44] i [Ref.31] -> Ús 4
# - Lambda delta = 0.8 -
print("Computing case lambda_delta = 0.8")
results_labda_delta2 = []
for lambda_value in lambda_values:
    # lambda = beta * k / mu ==> beta = lamda * mu / k
    beta1 = (lambda_value * mu) / k
    beta2 = (lambda_delta2 * mu) / k_delta
    scm = scm_order_2(rsc, beta1, beta2, mu, initial_infectious=0.01, time_steps=200) # Bibliografia: [Ref.31] -> Ús 4
    results_labda_delta2.append(np.mean(scm[-100:])) # Bibliografia: [Ref.44] i [Ref.31] -> Ús 4
# - Lambda delta = 2.5 -
print("Computing case lambda_delta = 2.5")
results_labda_delta3 = []
for lambda_value in lambda_values:
    # lambda = beta * k / mu ==> beta = lamda * mu / k
    beta1 = (lambda_value * mu) / k
    beta2 = (lambda_delta3 * mu) / k_delta
    scm = scm_order_2(rsc, beta1, beta2, mu, initial_infectious=0.01, time_steps=200) # Bibliografia: [Ref.31] -> Ús 4
    results_labda_delta3.append(np.mean(scm[-100:])) # Bibliografia: [Ref.44] i [Ref.31] -> Ús 4

Computing case lambda_delta = 0.0
Computing case lambda_delta = 0.8
Computing case lambda_delta = 2.5

# -- Càlculs gràfic 2 --
t = 500
initial_infectius = [round(value, 1) for value in np.arange(0.0, 1.0, 0.05)] # Taxes inicials d'infecciosos
lambda_value = 0.75
lambda_delta_value = 2.5
mu = 1.0
# lambda = beta * k / mu ==> beta = lamda * mu / k
beta = (lambda_value * mu) / k
beta_delta = (lambda_delta_value * mu) / k_delta
results = {} # Mappeig {infecciosos_inicials: resultats_scm}
for intitial in initial_infectius:
    res = scm_order_2(rsc, beta, beta_delta, mu, initial_infectious=intitial, time_steps=t)
    results[intitial] = res

t_range = [t for t in range(501)]
fig, ax = plt.subplots(1,2, figsize=(15,15))
fig.suptitle("Gràfics de densitat d'infectats vs lambda i densitat d'infectats vs. temps", fontsize=20)
ax[0].plot(lambda_values, results_labda_delta1, 'bo', label='lambda_delta = 0')
ax[0].plot(lambda_values, results_labda_delta2, 'ks', label='lambda_delta = 0.8')
ax[0].plot(lambda_values, results_labda_delta3, 'go', label='lambda_delta = 2.5')
ax[0].set_title("Densitat d'infectats vs lambda", fontsize=10)
ax[0].legend()
ax[0].set_ylabel("Density of infected")
ax[0].set_xlabel("Lambda")
cmap = plt.cm.viridis
norm = plt.Normalize(vmin=0.0, vmax=1.0)
for initial_infect, result in results.items():
    ax[1].plot(t_range, result, color=cmap(norm(initial_infect)))
ax[1].set_title("Densitat d'infectats vs temps", fontsize=10)
ax[1].set_ylabel("Density of infected")
ax[1].set_xlabel("Temps")
plt.show()

PEC 3: Xarxes Complexes¶

Càrrega de llibreries¶

Xarxa Multilacapa de "Game of Thrones" (6,5 punts)¶

Complexos Simplicials en contagis socials (3,5 punts)¶